package com.tedu.API;

import org.junit.Test;

/**
 * java面向对象-----不是真的面向对象----八大基础数据类型
 * 创建对象---类【属性、构造器、方法】
 * 8个包装类：针对八大基本数据类型提供的对应的类【方法基本互通】
 *          不可改变的类
 * 包装类包位置：Java.Lang
 * 八大基本数据类型（不是面向对象）：        八大基本数据类型的包装类
 *               int                       Integer       继承Number父类【抽象】
 *               long                      Long          继承Number父类【抽象】
 *               double                    Double        继承Number父类【抽象】
 *               short                     Short         继承Number父类【抽象】
 *               float                     Float         继承Number父类【抽象】
 *               byte                      Byte          继承Number父类【抽象】
 *               char                      Character     继承Object父类
 *               boolean                   Boolean       继承Object父类
 */
public class PackingAPI {
    @Test
    public void test(){
        int a=1;  //不是面向对象,通过.【反射】
        //创建int类型的对象：Integer构造器：引入|直接写
        Integer i=new Integer(a);
        i.toString();
    }
    /**
     * 包装类API
     * xxxValue方法====静态方法valueOf    返回值：对应数据类型
     * 作用：把包装类转换为基本数据类型的方法
     * 测试：6个包装类
     */
    @Test
    public void testxxxValue(){
        Integer i=new Integer(2);//打包：把对应类型放入包装类
        i=i.intValue();  //拆包------接收：int类型和Integer
        System.out.println(i);

        //测试：其他7个包装类
        //String s1="123.123"    Double
        String s1="123.123";
        Double d=new Double(s1);
        d=d.doubleValue();
        System.out.println(d);

        //String s2="1"          Byte
        String s2="1";
        Byte b=new Byte(s2);
        b.byteValue();
        System.out.println(b);

        //String s3="123.123F"   Float     123.1默认Double
        String s3="123.123F";
        Float f=new Float(s3);
        f=f.floatValue();
        System.out.println(f);

        //String s4="1234L"      Long异常：NumberFormatException 数值转换异常
        //包装类构造器：直接传值，【使用字符串传值：long包认为L字符，并不是数值】
        String s4="1234";
        Long l=new Long(s4);
        l=l.longValue();
        System.out.println(l);

        //String s5="true"       Boolean
        String s5="true";
        Boolean b1=new Boolean(s5);
        b1=b1.booleanValue();
        System.out.println(b1);

        //String s6="a"          Character
        char s6='a';
        Character c=new Character(s6);
        c=c.charValue();
        System.out.println(c);
    }

    /**包装类具备
     * valueOf()   返回值：对应数据类型
     * 作用：把包装类转换为基本数据类型的方法
     */
    @Test
    public void testValueof(){
        int i=Integer.valueOf(1);//打包拆包一体化
        boolean b=Boolean.valueOf(true);
        char c=Character.valueOf('1');
        Float.valueOf(1.123F);//1.123默认  double  编译工具
    }
    /**
     * 包装类----------Servlet[JavaBean]
     * public class Person{
     *     Integer id;  //成员变量-------解析
     * }
     * parseXXX()      静态方发     返回值：对应的类型
     * 作用：可以将获取到的字符串转化为对应类型
     */
    @Test
    public void testParseXXX(){
        String s="123";//将字符串转化为整型
        int i=Integer.parseInt(s);//区别：解析字符串，转为正确类型
        int is=Integer.valueOf(s);//区别：存入值，打包拆包获取值
        System.out.println(i);
        //将整型转化为字符串
        String s1=String.valueOf(12345);//与包装类，用法一致，实现不一致
    }

    @Test
    public void s(){
        //自己测:①  String s2="456f"
        //      ②  char s="a";
        String s2="456f";
        Float i=Float.parseFloat(s2);
        System.out.println(i);

        char s='a';
//        Character  没有针对字符解析

    }
    /**
     * 自动拆装箱
     * JDK1.5之前是没有自动拆装箱
     * JDK1.5之后是自动拆装箱   2004
     */
    @Test
    public void testJ(){
        //JDK1.5之前是没有自动拆装箱
        Integer in=Integer.valueOf(1);//装箱
        int ii=in.intValue();//拆箱
        //JDK1.5之后是自动拆装箱
        Integer i=1;
        int is=i;
        //编译器帮我们写了拆装箱过程----JVM虚拟机认1.5之前的写法
    }
}
